home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 4: GNU Archives / Linux Cubed Series 4 - GNU Archives.iso / gnu / fontutil.6 / fontutil / fontutils-0.6 / charspace / symtab.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-06-14  |  7.5 KB  |  323 lines
  1. /* symtab.c: create and update a symbol table.  We use a simple linear
  2.    representation, since there will be a few hundred entries at
  3.    the very most.
  4.    
  5.    The numbers which get stored in the symbol table should all be in
  6.    pixels.  That's what the rest of the program expects.  (Unfortunately
  7.    there's no way to check this at the time of definition.)
  8.  
  9. Copyright (C) 1992 Free Software Foundation, Inc.
  10.  
  11. This program is free software; you can redistribute it and/or modify
  12. it under the terms of the GNU General Public License as published by
  13. the Free Software Foundation; either version 2, or (at your option)
  14. any later version.
  15.  
  16. This program is distributed in the hope that it will be useful,
  17. but WITHOUT ANY WARRANTY; without even the implied warranty of
  18. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19. GNU General Public License for more details.
  20.  
  21. You should have received a copy of the GNU General Public License
  22. along with this program; if not, write to the Free Software
  23. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  24.  
  25. #include "config.h"
  26.  
  27. #include "kern.h"
  28. #include "main.h"
  29. #include "symtab.h"
  30.  
  31.  
  32. /* Every identifier in the CMI files -- character names and fontdimen
  33.    names as well as `define'd quantities -- gets put into our symbol
  34.    table.  We do not resolve any definitions until they are actually
  35.    needed, so that later definitions will replace earlier ones.  */
  36. struct symbol
  37. {
  38.   string key;
  39.   symval_type value;
  40.   struct symbol *next;
  41. };
  42.  
  43. /* These all work on pointers instead of structures, since that's what
  44.    we need to pass around in this file.  */
  45. #define SYM_KEY(s)    ((s)->key)
  46. #define SYM_NEXT(s)    ((s)->next)
  47. #define SYM_VAL(s)    ((s)->value)
  48.  
  49. typedef struct symbol symbol_type;
  50.  
  51.  
  52. /* We have only one symbol table.  Here it is.  */
  53. static symbol_type *symbol_table = NULL;
  54.  
  55.  
  56. static symbol_type *symtab_find (string);
  57. static boolean resolve_string (symval_type *, real);
  58.  
  59. /* Routines to create symval nodes.  */
  60.  
  61. symval_type
  62. symtab_char_node (symval_type lsb, symval_type rsb)
  63. {
  64.   symval_type sv;
  65.   
  66.   SYMVAL_TAG (sv) = symval_char;
  67.   SYMVAL_CHAR (sv) = init_char ();
  68.  
  69.   CHAR_LSB (SYMVAL_CHAR (sv)) = XTALLOC1 (sidebearing_type);
  70.   CHAR_LSB_TAG (SYMVAL_CHAR (sv)) = SYMVAL_TAG (lsb);
  71.   CHAR_LSB_VALUE (SYMVAL_CHAR (sv)) = SYMVAL_REAL_STRING (lsb);
  72.  
  73.   CHAR_RSB (SYMVAL_CHAR (sv)) = XTALLOC1 (sidebearing_type);
  74.   CHAR_RSB_TAG (SYMVAL_CHAR (sv)) = SYMVAL_TAG (rsb);
  75.   CHAR_RSB_VALUE (SYMVAL_CHAR (sv)) = SYMVAL_REAL_STRING (rsb);
  76.   
  77.   return sv;
  78. }
  79.  
  80.  
  81. symval_type
  82. symtab_real_node (real r)
  83. {
  84.   symval_type sv;
  85.   
  86.   SYMVAL_TAG (sv) = symval_real;
  87.   SYMVAL_REAL (sv) = r;
  88.  
  89.   return sv;
  90. }
  91.  
  92.  
  93. symval_type
  94. symtab_real_string_node (real r, string s)
  95. {
  96.   symval_type sv;
  97.   
  98.   SYMVAL_TAG (sv) = symval_real_string;
  99.   SYMVAL_REAL (sv) = r;
  100.   SYMVAL_STRING (sv) = s;
  101.  
  102.   return sv;
  103. }
  104.  
  105.  
  106. symval_type
  107. symtab_string_node (string s)
  108. {
  109.   symval_type sv;
  110.   
  111.   SYMVAL_TAG (sv) = symval_string;
  112.   SYMVAL_STRING (sv) = s;
  113.  
  114.   return sv;
  115. }
  116.  
  117. /* Define the identifier KEY to be the value V.  We do no checking on V,
  118.    we just plop it in.  Overwrite any previous definition of KEY.  If
  119.    KEY was not previously defined, we malloc a new symbol.  */
  120.  
  121. void 
  122. symtab_define (string key, symval_type v)
  123. {
  124.   symbol_type *s = symtab_find (key);
  125.  
  126.   if (s == NULL)
  127.     {
  128.       s = XTALLOC1 (symbol_type);
  129.       
  130.       /* Make a private copy of KEY so outside assignments or
  131.          deallocations don't affect the symbol table.  */
  132.       SYM_KEY (s) = xstrdup (key);
  133.       SYM_NEXT (s) = symbol_table;
  134.       symbol_table = s;
  135.     }
  136.  
  137.   /* Whether we just created it or not, put in the new value.  */
  138.   SYM_VAL (s) = v;
  139. }
  140.  
  141. /* Define a kern of K pixels between the characters named LEFT and
  142.    RIGHT.  If no kern for that pair previously existed, we create it.
  143.    If the character LEFT was not previously in the symbol table, we add
  144.    it.  But if LEFT was in the symbol table, we have to preserve any
  145.    kerns or side bearing information that have already been stored.  */
  146.  
  147. void
  148. symtab_define_kern (string left, string right, symval_type k)
  149. {
  150.   symval_type sv;
  151.   symbol_type *s = symtab_find (left);
  152.   
  153.   if (s == NULL || SYMVAL_TAG (SYM_VAL (s)) != symval_char)
  154.     {
  155.       list_type *kern_list_ptr;
  156.       char_kern_type *new_kern;
  157.       
  158.       SYMVAL_TAG (sv) = symval_char;
  159.       SYMVAL_CHAR (sv) = init_char ();
  160.       
  161.       kern_list_ptr = &CHAR_KERNS (SYMVAL_CHAR (sv));
  162.       new_kern = LIST_TAPPEND (kern_list_ptr, char_kern_type);
  163.       new_kern->character = right;
  164.       new_kern->kern = k;
  165.     }
  166.   else
  167.     {
  168.       sv = SYM_VAL (s);
  169.       char_set_kern (&CHAR_KERNS (SYMVAL_CHAR (sv)), right, k);
  170.     }
  171.   
  172.   symtab_define (left, sv);
  173. }
  174.  
  175. /* Look up KEY in `symbol_table'.  If found, return a pointer to the
  176.    corresponding symval, else NULL.  */
  177.  
  178. symval_type *
  179. symtab_lookup (string key)
  180. {
  181.   symbol_type *s = symtab_find (key);
  182.   symval_type *sv = s ? &SYM_VAL (s) : NULL;
  183.   
  184.   return sv;
  185. }
  186.  
  187.  
  188. /* Look up KEY in `symbol_table', resolve its definition to a real, and
  189.    return the result.  If the value cannot be resolved, or if KEY isn't
  190.    defined, give a fatal error.  */
  191.  
  192. real
  193. symtab_lookup_real (string key)
  194. {
  195.   real r;
  196.   symval_type *sv = symtab_lookup (key);
  197.   
  198.   if (sv == NULL)
  199.     FATAL1 ("%s: Undefined symbol", key);
  200.  
  201.   if (symval_resolve (sv))
  202.     r = SYMVAL_REAL (*sv);
  203.   else
  204.     FATAL1 ("%s: Cannot be resolved to a real", key);
  205.  
  206.   return r;
  207. }
  208.  
  209.  
  210. /* Look up KEY in `symbol_table'.  If found, return the containing
  211.    symbol, otherwise NULL.  */
  212.  
  213. static symbol_type *
  214. symtab_find (string key)
  215. {
  216.   symbol_type *s;
  217.  
  218.   assert (key != NULL);
  219.  
  220.   for (s = symbol_table; s != NULL && !STREQ (SYM_KEY (s), key);
  221.        s = SYM_NEXT (s))
  222.     ;
  223.  
  224.   return s;
  225. }
  226.  
  227. /* Resolve (to a real) the symbol value SV.  Change SV if we succeed.
  228.    Return success.  */
  229.  
  230. boolean
  231. symval_resolve (symval_type *sv)
  232. {
  233.   boolean ok;
  234.   
  235.   if (sv == NULL)
  236.     return false;
  237.     
  238.   switch (SYMVAL_TAG (*sv))
  239.     {
  240.     case symval_char:
  241.       ok = false;
  242.       break;
  243.     
  244.     case symval_real:
  245.       ok = true;
  246.       break;
  247.       
  248.     case symval_real_string:
  249.       ok = resolve_string (sv, SYMVAL_REAL (*sv));
  250.       break;
  251.     
  252.     case symval_string:
  253.       ok = resolve_string (sv, 1.0);
  254.       break;
  255.     
  256.     default:
  257.       abort (); /* We have listed all the cases.  */
  258.     }
  259.   
  260.   return ok;
  261. }
  262.  
  263.  
  264. /* Assume SV is non-null, and that its SYMVAL_STRING field is
  265.    meaningful.  Look up that string, resolve the result.  If that
  266.    succeeds, multiply by FACTOR, change SV, and return success.  */
  267.  
  268. static boolean
  269. resolve_string (symval_type *sv, real factor)
  270. {
  271.   boolean ok = false;
  272.   
  273.   symval_type *sv_aux = symtab_lookup (SYMVAL_STRING (*sv));
  274.  
  275.   if (symval_resolve (sv_aux))
  276.     {
  277.       SYMVAL_TAG (*sv) = symval_real;
  278.       SYMVAL_REAL (*sv) = SYMVAL_REAL (*sv_aux) * factor;
  279.       ok = true;
  280.     }
  281.   
  282.   return ok;
  283. }
  284.  
  285. /* Return a description of SV as a string.  */
  286.  
  287. string
  288. symval_as_string (symval_type sv)
  289. {
  290.   string desc;
  291.   
  292.   switch (SYMVAL_TAG (sv))
  293.     {
  294.     case symval_char:
  295.       {
  296.         string charcode = CHAR_BITMAP_INFO (SYMVAL_CHAR (sv)) != NULL
  297.                         ? concat (" ", utoa (CHAR_CHARCODE (SYMVAL_CHAR (sv))))
  298.                         : "";
  299.         desc = concat ("character", charcode);
  300.         if (*charcode != 0)
  301.           free (charcode);
  302.       }
  303.       break;
  304.     
  305.     case symval_real:
  306.       desc = dtoa (SYMVAL_REAL (sv));
  307.       break;
  308.       
  309.     case symval_real_string:
  310.       desc = concat (dtoa (SYMVAL_REAL (sv)), SYMVAL_STRING (sv));
  311.       break;
  312.     
  313.     case symval_string:
  314.       desc = xstrdup (SYMVAL_STRING (sv));
  315.       break;
  316.     
  317.     default:
  318.       abort (); /* We have listed all the cases.  */
  319.     }
  320.   
  321.   return desc;
  322. }
  323.